<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>命令模式的实现机制 - 技术小馆</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.6;
        }
        h1, h2, h3, h4 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
        }
        .hero-bg {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        }
        .code-block {
            background-color: #2d3748;
            border-radius: 0.5rem;
            padding: 1.5rem;
            position: relative;
        }
        .code-block pre {
            color: #f7fafc;
            font-family: 'Courier New', Courier, monospace;
            overflow-x: auto;
        }
        .card {
            transition: all 0.3s ease;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
        }
        .card:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 15px rgba(0, 0, 0, 0.1);
        }
        .command-item {
            border-left: 4px solid #667eea;
            transition: all 0.3s ease;
        }
        .command-item:hover {
            background-color: #f8fafc;
            border-left-width: 6px;
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero-bg text-white py-20 px-4 sm:px-6 lg:px-8">
        <div class="max-w-5xl mx-auto text-center">
            <h1 class="text-4xl md:text-5xl font-bold mb-6">命令模式的实现机制</h1>
            <p class="text-xl md:text-2xl max-w-3xl mx-auto mb-8">解耦请求发送者与接收者，构建灵活可扩展的系统架构</p>
            <div class="flex justify-center space-x-4">
                <span class="inline-flex items-center px-3 py-1 rounded-full bg-white bg-opacity-20 text-sm">
                    <i class="fas fa-code mr-1"></i> 设计模式
                </span>
                <span class="inline-flex items-center px-3 py-1 rounded-full bg-white bg-opacity-20 text-sm">
                    <i class="fas fa-cogs mr-1"></i> 系统架构
                </span>
                <span class="inline-flex items-center px-3 py-1 rounded-full bg-white bg-opacity-20 text-sm">
                    <i class="fas fa-project-diagram mr-1"></i> 解耦
                </span>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="max-w-5xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
        <!-- Introduction -->
        <section class="mb-16">
            <div class="prose prose-lg max-w-none text-gray-700">
                <p class="text-xl leading-relaxed mb-6">
                    命令模式是一种行为设计模式，它允许将请求封装为对象，从而使得我们可以对请求进行参数化、延迟执行、支持撤销和重做等操作。这种模式的核心在于将请求的发送者与接收者解耦，从而提高系统的灵活性和可扩展性。
                </p>
                
                <div class="my-8">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1727419635682-973dba1d-b90b-4618-bb80-8069aa6c2de1.png" 
                         alt="命令模式示意图" 
                         class="w-full rounded-lg shadow-lg">
                </div>
                
                <p class="text-xl leading-relaxed">
                    在当今的软件开发中，尤其是在构建复杂的事件驱动系统时，命令模式的价值尤为突出。事件驱动架构强调异步处理和响应性，而命令模式则为我们提供了一种简洁且高效的方式来管理这些异步事件。当一个事件发生时，系统可以根据需要创建相应的命令对象，然后通过调用者将其传递到接收者进行处理。这种解耦的设计使得我们可以轻松地扩展和修改系统的行为，而无需改动请求的发送者。
                </p>
            </div>
        </section>

        <!-- Definition Section -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 border-b pb-2">命令模式的定义</h2>
            <div class="prose prose-lg max-w-none text-gray-700">
                <p>
                    命令模式（Command Pattern）是一种行为设计模式，它通过将请求封装为对象，从而将请求的发起者与执行者解耦。这种模式允许我们将操作的参数化、延迟执行、排队请求以及支持撤销和重做等功能进行实现。
                </p>
                
                <div class="my-8">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1727419711677-32138c4e-508c-4ed4-b1dc-73b232cc9c08.png" 
                         alt="命令模式结构图" 
                         class="w-full rounded-lg shadow-lg">
                </div>
            </div>
            
            <!-- Components Section -->
            <div class="mt-10">
                <h3 class="text-2xl font-semibold mb-4 text-gray-700">1. 组成部分</h3>
                
                <div class="grid md:grid-cols-2 gap-6">
                    <!-- Command Interface -->
                    <div class="command-item bg-white p-6 rounded-lg shadow-sm">
                        <div class="flex items-start mb-4">
                            <div class="bg-blue-100 p-2 rounded-full mr-4">
                                <i class="fas fa-code text-blue-600"></i>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg text-gray-800">命令接口（Command）</h4>
                                <p class="text-gray-600">
                                    定义一个抽象接口，声明一个执行操作的方法。所有具体命令类都需实现这个接口。
                                </p>
                            </div>
                        </div>
                    </div>
                    
                    <!-- Concrete Command -->
                    <div class="command-item bg-white p-6 rounded-lg shadow-sm">
                        <div class="flex items-start mb-4">
                            <div class="bg-purple-100 p-2 rounded-full mr-4">
                                <i class="fas fa-cubes text-purple-600"></i>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg text-gray-800">具体命令类（ConcreteCommand）</h4>
                                <p class="text-gray-600">
                                    实现命令接口，具体的命令类中封装了对接收者的调用，并在执行时调用接收者的方法。
                                </p>
                            </div>
                        </div>
                    </div>
                    
                    <!-- Receiver -->
                    <div class="command-item bg-white p-6 rounded-lg shadow-sm">
                        <div class="flex items-start mb-4">
                            <div class="bg-green-100 p-2 rounded-full mr-4">
                                <i class="fas fa-server text-green-600"></i>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg text-gray-800">接收者（Receiver）</h4>
                                <p class="text-gray-600">
                                    负责执行具体操作的类。接收者了解如何实现与请求相关的操作。
                                </p>
                            </div>
                        </div>
                    </div>
                    
                    <!-- Invoker -->
                    <div class="command-item bg-white p-6 rounded-lg shadow-sm">
                        <div class="flex items-start mb-4">
                            <div class="bg-yellow-100 p-2 rounded-full mr-4">
                                <i class="fas fa-play text-yellow-600"></i>
                            </div>
                            <div>
                                <h4 class="font-bold text-lg text-gray-800">调用者（Invoker）</h4>
                                <p class="text-gray-600">
                                    存储命令对象，并在需要时调用该命令的执行方法。调用者与具体命令解耦。
                                </p>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
            
            <!-- Core Idea Section -->
            <div class="mt-10">
                <h3 class="text-2xl font-semibold mb-4 text-gray-700">2. 核心思想</h3>
                <p class="text-gray-700 mb-6">
                    命令模式的核心思想在于将请求的执行与请求的调用分离，使得发送请求的对象与处理请求的对象之间不再直接关联。这种解耦设计带来了以下几个主要优势：
                </p>
                
                <div class="grid md:grid-cols-3 gap-6">
                    <div class="card bg-white p-6 rounded-lg">
                        <div class="text-blue-500 text-3xl mb-4">
                            <i class="fas fa-exchange-alt"></i>
                        </div>
                        <h4 class="font-bold text-lg mb-2">灵活性</h4>
                        <p class="text-gray-600">
                            通过引入命令对象，可以动态地改变请求的执行方式。可以轻松添加新命令而无需修改现有代码。
                        </p>
                    </div>
                    
                    <div class="card bg-white p-6 rounded-lg">
                        <div class="text-purple-500 text-3xl mb-4">
                            <i class="fas fa-undo"></i>
                        </div>
                        <h4 class="font-bold text-lg mb-2">支持撤销/重做</h4>
                        <p class="text-gray-600">
                            通过维护命令的历史记录，可以实现操作的撤销和重做功能。这在许多应用场景中非常重要。
                        </p>
                    </div>
                    
                    <div class="card bg-white p-6 rounded-lg">
                        <div class="text-green-500 text-3xl mb-4">
                            <i class="fas fa-list-ol"></i>
                        </div>
                        <h4 class="font-bold text-lg mb-2">命令队列</h4>
                        <p class="text-gray-600">
                            可以将命令对象放入队列中进行排队处理，这在异步处理和多线程环境中特别有用。
                        </p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Implementation Details -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 border-b pb-2">命令模式的实现</h2>
            
            <div class="prose prose-lg max-w-none text-gray-700 mb-8">
                <p>
                    命令模式的实现涉及多个类的协作，每个类在模式中扮演特定的角色。以下是命令模式的具体实现过程，通常包括以下几个步骤：
                </p>
            </div>
            
            <!-- Implementation Steps -->
            <div class="space-y-10">
                <!-- Step 1 -->
                <div class="flex flex-col md:flex-row gap-8">
                    <div class="md:w-1/3">
                        <div class="bg-blue-50 p-4 rounded-lg h-full">
                            <h3 class="text-xl font-semibold mb-3 text-blue-700">
                                <span class="bg-blue-600 text-white rounded-full w-8 h-8 inline-flex items-center justify-center mr-2">1</span>
                                定义命令接口
                            </h3>
                            <p class="text-gray-700">
                                首先，我们需要定义一个命令接口，声明执行命令的方法。该接口提供了一种统一的方式来调用不同的命令。
                            </p>
                        </div>
                    </div>
                    <div class="md:w-2/3">
                        <div class="code-block">
                            <pre><code>public interface Command {
    void execute();
}</code></pre>
                        </div>
                    </div>
                </div>
                
                <!-- Step 2 -->
                <div class="flex flex-col md:flex-row gap-8">
                    <div class="md:w-1/3">
                        <div class="bg-purple-50 p-4 rounded-lg h-full">
                            <h3 class="text-xl font-semibold mb-3 text-purple-700">
                                <span class="bg-purple-600 text-white rounded-full w-8 h-8 inline-flex items-center justify-center mr-2">2</span>
                                实现具体命令类
                            </h3>
                            <p class="text-gray-700">
                                我们实现具体命令类，继承命令接口。每个具体命令类实现了命令接口中的 `execute()` 方法，并持有一个接收者的引用。
                            </p>
                        </div>
                    </div>
                    <div class="md:w-2/3">
                        <div class="code-block">
                            <pre><code>public class LightOnCommand implements Command {
    private Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOn();
    }
}

public class LightOffCommand implements Command {
    private Light light;

    public LightOffCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOff();
    }
}</code></pre>
                        </div>
                    </div>
                </div>
                
                <!-- Step 3 -->
                <div class="flex flex-col md:flex-row gap-8">
                    <div class="md:w-1/3">
                        <div class="bg-green-50 p-4 rounded-lg h-full">
                            <h3 class="text-xl font-semibold mb-3 text-green-700">
                                <span class="bg-green-600 text-white rounded-full w-8 h-8 inline-flex items-center justify-center mr-2">3</span>
                                定义接收者
                            </h3>
                            <p class="text-gray-700">
                                接收者是实际执行命令的类。它包含了实现具体操作的方法。
                            </p>
                        </div>
                    </div>
                    <div class="md:w-2/3">
                        <div class="code-block">
                            <pre><code>public class Light {
    public void turnOn() {
        System.out.println("Light is ON");
    }

    public void turnOff() {
        System.out.println("Light is OFF");
    }
}</code></pre>
                        </div>
                    </div>
                </div>
                
                <!-- Step 4 -->
                <div class="flex flex-col md:flex-row gap-8">
                    <div class="md:w-1/3">
                        <div class="bg-yellow-50 p-4 rounded-lg h-full">
                            <h3 class="text-xl font-semibold mb-3 text-yellow-700">
                                <span class="bg-yellow-600 text-white rounded-full w-8 h-8 inline-flex items-center justify-center mr-2">4</span>
                                实现调用者
                            </h3>
                            <p class="text-gray-700">
                                调用者类持有命令对象，并提供方法来执行命令。调用者通过命令接口调用具体命令的 `execute()` 方法。
                            </p>
                        </div>
                    </div>
                    <div class="md:w-2/3">
                        <div class="code-block">
                            <pre><code>public class RemoteControl {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void pressButton() {
        command.execute();
    }
}</code></pre>
                        </div>
                    </div>
                </div>
                
                <!-- Step 5 -->
                <div class="flex flex-col md:flex-row gap-8">
                    <div class="md:w-1/3">
                        <div class="bg-indigo-50 p-4 rounded-lg h-full">
                            <h3 class="text-xl font-semibold mb-3 text-indigo-700">
                                <span class="bg-indigo-600 text-white rounded-full w-8 h-8 inline-flex items-center justify-center mr-2">5</span>
                                客户端代码
                            </h3>
                            <p class="text-gray-700">
                                客户端负责创建命令对象、设置接收者，并将命令对象传递给调用者。客户端也负责控制命令的执行。
                            </p>
                        </div>
                    </div>
                    <div class="md:w-2/3">
                        <div class="code-block">
                            <pre><code>public class Client {
    public static void main(String[] args) {
        Light light = new Light();
        Command lightOn = new LightOnCommand(light);
        Command lightOff = new LightOffCommand(light);

        RemoteControl remote = new RemoteControl();
        
        // 开灯
        remote.setCommand(lightOn);
        remote.pressButton();

        // 关灯
        remote.setCommand(lightOff);
        remote.pressButton();
    }
}</code></pre>
                        </div>
                    </div>
                </div>
            </div>
            
            <!-- Extensibility Section -->
            <div class="mt-12 bg-gray-50 p-6 rounded-lg border border-gray-200">
                <h3 class="text-2xl font-semibold mb-4 text-gray-700">扩展性与灵活性</h3>
                <p class="text-gray-700 mb-4">
                    通过命令模式，可以很容易地添加新的命令而无需更改现有代码。例如，假设我们想添加一个新的命令来调节灯光的亮度，只需实现一个新的具体命令类，并将其传递给调用者即可。这样，命令模式使得系统具有更高的扩展性和可维护性。
                </p>
                
                <h4 class="text-xl font-semibold mb-3 text-gray-700">支持复杂操作</h4>
                <div class="grid md:grid-cols-2 gap-6 mt-4">
                    <div class="bg-white p-4 rounded-lg border border-gray-200">
                        <h5 class="font-bold text-blue-600 mb-2"><i class="fas fa-undo-alt mr-2"></i>撤销和重做</h5>
                        <p class="text-gray-600">
                            可以维护一个命令历史记录，允许用户撤销或重做操作。
                        </p>
                    </div>
                    <div class="bg-white p-4 rounded-lg border border-gray-200">
                        <h5 class="font-bold text-purple-600 mb-2"><i class="fas fa-layer-group mr-2"></i>宏命令</h5>
                        <p class="text-gray-600">
                            可以将多个命令组合成一个宏命令，通过一个命令一次性执行多个操作。
                        </p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Application in Event-Driven Systems -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 border-b pb-2">命令模式在事件驱动系统中的应用</h2>
            
            <div class="prose prose-lg max-w-none text-gray-700 mb-8">
                <p>
                    命令模式在事件驱动系统中的应用十分广泛，它通过将请求封装为对象，使得事件的产生与处理之间实现解耦，极大地增强了系统的灵活性和可维护性。
                </p>
            </div>
            
            <!-- Applications -->
            <div class="grid md:grid-cols-2 gap-8">
                <div class="bg-white p-6 rounded-lg shadow-sm border-l-4 border-blue-500">
                    <h3 class="text-xl font-semibold mb-3 text-gray-800">1. 事件处理解耦</h3>
                    <p class="text-gray-600 mb-4">
                        在事件驱动架构中，事件的产生者与事件的处理者之间通常需要保持松散耦合。命令模式通过定义命令对象来实现这一目标：
                    </p>
                    <ul class="text-gray-600 space-y-2">
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-blue-500 mt-1 mr-2"></i>
                            <span>事件生成: 当一个事件发生时，例如用户点击按钮，系统会生成一个对应的命令对象</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-blue-500 mt-1 mr-2"></i>
                            <span>事件处理: 该命令对象被传递到事件处理器（通常是调用者），调用者执行命令，从而触发相应的业务逻辑</span>
                        </li>
                    </ul>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm border-l-4 border-purple-500">
                    <h3 class="text-xl font-semibold mb-3 text-gray-800">2. 支持异步操作</h3>
                    <p class="text-gray-600 mb-4">
                        在高并发的事件驱动系统中，异步处理非常重要。命令模式可以很好地支持异步执行：
                    </p>
                    <ul class="text-gray-600 space-y-2">
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-purple-500 mt-1 mr-2"></i>
                            <span>命令排队: 当事件产生速度超过处理能力时，命令可以被排队存储，以便稍后执行</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-purple-500 mt-1 mr-2"></i>
                            <span>异步执行: 使用线程池或消息队列等机制，可以将命令异步执行，从而提升系统的响应能力</span>
                        </li>
                    </ul>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm border-l-4 border-green-500">
                    <h3 class="text-xl font-semibold mb-3 text-gray-800">3. 撤销与重做操作</h3>
                    <p class="text-gray-600 mb-4">
                        在用户交互频繁的系统中，支持撤销和重做操作是用户体验的重要组成部分。命令模式使得这一功能的实现变得简单：
                    </p>
                    <ul class="text-gray-600 space-y-2">
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                            <span>命令历史: 系统可以维护一个命令历史栈，记录用户执行的每一个命令</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                            <span>撤销与重做: 当用户选择撤销操作时，系统只需调用上一个命令的撤销方法；而重做操作则可以重新执行之前的命令</span>
                        </li>
                    </ul>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm border-l-4 border-yellow-500">
                    <h3 class="text-xl font-semibold mb-3 text-gray-800">4. 宏命令的实现</h3>
                    <p class="text-gray-600 mb-4">
                        宏命令是指将多个命令组合成一个命令，一次性执行多个操作。在事件驱动系统中，这种特性非常有用：
                    </p>
                    <ul class="text-gray-600 space-y-2">
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-yellow-500 mt-1 mr-2"></i>
                            <span>批量处理: 可以将一系列操作封装为一个宏命令，以便在一次事件响应中执行</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-yellow-500 mt-1 mr-2"></i>
                            <span>灵活配置: 用户可以根据需求动态配置宏命令，从而实现不同的业务逻辑</span>
                        </li>
                    </ul>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm border-l-4 border-red-500 md:col-span-2">
                    <h3 class="text-xl font-semibold mb-3 text-gray-800">5. 事件日志与审计</h3>
                    <p class="text-gray-600 mb-4">
                        命令模式还可以用于实现事件日志和审计功能：
                    </p>
                    <ul class="text-gray-600 space-y-2">
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-red-500 mt-1 mr-2"></i>
                            <span>记录事件: 每次执行命令时，可以将命令对象及其参数记录到日志中，以便进行后续审计或分析</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-red-500 mt-1 mr-2"></i>
                            <span>回放操作: 通过命令日志，可以实现系统的状态恢复或操作的重放，从而支持系统故障后的恢复操作</span>
                        </li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Pros & Cons -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 border-b pb-2">命令模式的优缺点</h2>
            
            <div class="prose prose-lg max-w-none text-gray-700 mb-8">
                <p>
                    命令模式作为一种行为设计模式，在软件设计中有着广泛的应用。尽管其带来了许多优势，但也存在一些缺点。
                </p>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <!-- Advantages -->
                <div>
                    <h3 class="text-2xl font-semibold mb-4 text-green-600">优点</h3>
                    <ul class="space-y-4">
                        <li class="flex items-start">
                            <div class="bg-green-100 p-2 rounded-full mr-4">
                                <i class="fas fa-thumbs-up text-green-600"></i>
                            </div>
                            <div>
                                <h4 class="font-bold text-gray-800">解耦请求发送者与接收者</h4>
                                <p class="text-gray-600">
                                    通过将请求封装为命令对象，命令模式使得请求的发起者与实际执行请求的对象解耦。这种解耦允许两者独立演进，减少了系统之间的依赖。
                                </p>
                            </div>
                        </li>
                        
                        <li class="flex items-start">
                            <div class="bg-green-100 p-2 rounded-full mr-4">
                                <i class="fas fa-thumbs-up text-green-600"></i>
                            </div>
                            <div>
                                <h4 class="font-bold text-gray-800">支持撤销和重做操作</h4>
                                <p class="text-gray-600">
                                    通过维护命令的历史记录，系统可以方便地实现操作的撤销与重做。这在许多应用场景中非常重要，尤其是图形用户界面和编辑器等。
                                </p>
                            </div>
                        </li>
                        
                        <li class="flex items-start">
                            <div class="bg-green-100 p-2 rounded-full mr-4">
                                <i class="fas fa-thumbs-up text-green-600"></i>
                            </div>
                            <div>
                                <h4 class="font-bold text-gray-800">增强系统的灵活性和可扩展性</h4>
                                <p class="text-gray-600">
                                    新命令可以通过实现命令接口轻松添加，而无需修改现有代码。这使得系统能够灵活应对需求变化。
                                </p>
                            </div>
                        </li>
                        
                        <li class="flex items-start">
                            <div class="bg-green-100 p-2 rounded-full mr-4">
                                <i class="fas fa-thumbs-up text-green-600"></i>
                            </div>
                            <div>
                                <h4 class="font-bold text-gray-800">命令队列和异步处理</h4>
                                <p class="text-gray-600">
                                    命令模式能够轻松实现命令的排队与异步执行，适用于高并发和复杂的事件驱动场景。通过将命令发送到队列，系统可以灵活地处理请求，提高响应性。
                                </p>
                            </div>
                        </li>
                        
                        <li class="flex items-start">
                            <div class="bg-green-100 p-2 rounded-full mr-4">
                                <i class="fas fa-thumbs-up text-green-600"></i>
                            </div>
                            <div>
                                <h4 class="font-bold text-gray-800">支持宏命令</h4>
                                <p class="text-gray-600">
                                    可以将多个命令组合成一个宏命令，便于一次性执行多个操作。这在批处理和复杂事务处理中非常有用。
                                </p>
                            </div>
                        </li>
                    </ul>
                </div>
                
                <!-- Disadvantages -->
                <div>
                    <h3 class="text-2xl font-semibold mb-4 text-red-600">缺点</h3>
                    <ul class="space-y-4">
                        <li class="flex items-start">
                            <div class="bg-red-100 p-2 rounded-full mr-4">
                                <i class="fas fa-exclamation-circle text-red-600"></i>
                            </div>
                            <div>
                                <h4 class="font-bold text-gray-800">增加系统复杂性</h4>
                                <p class="text-gray-600">
                                    引入命令模式可能导致系统中类的数量增加，增加了设计和理解的复杂度。对于小型项目或简单的场景，命令模式可能显得过于复杂。
                                </p>
                            </div>
                        </li>
                        
                        <li class="flex items-start">
                            <div class="bg-red-100 p-2 rounded-full mr-4">
                                <i class="fas fa-exclamation-circle text-red-600"></i>
                            </div>
                            <div>
                                <h4 class="font-bold text-gray-800">性能开销</h4>
                                <p class="text-gray-600">
                                    封装命令对象和维护命令历史记录会带来一定的性能开销。在高频率调用的情况下，可能会影响系统的整体性能。
                                </p>
                            </div>
                        </li>
                        
                        <li class="flex items-start">
                            <div class="bg-red-100 p-2 rounded-full mr-4">
                                <i class="fas fa-exclamation-circle text-red-600"></i>
                            </div>
                            <div>
                                <h4 class="font-bold text-gray-800">难以实现复杂的参数传递</h4>
                                <p class="text-gray-600">
                                    在某些情况下，命令的执行需要多个参数或复杂的状态信息，简单的命令接口可能难以满足这些需求。这可能需要设计更复杂的命令对象，从而增加实现的复杂性。
                                </p>
                            </div>
                        </li>
                        
                        <li class="flex items-start">
                            <div class="bg-red-100 p-2 rounded-full mr-4">
                                <i class="fas fa-exclamation-circle text-red-600"></i>
                            </div>
                            <div>
                                <h4 class="font-bold text-gray-800">不适合所有场景</h4>
                                <p class="text-gray-600">
                                    对于一些简单的命令或操作，使用命令模式可能显得过于冗余。在这种情况下，直接调用方法可能更为简洁明了。
                                </p>
                            </div>
                        </li>
                    </ul>
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-300 py-10">
        <div class="max-w-5xl mx-auto px-4 sm:px-6 lg:px-8">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-bold text-white">技术小馆</h3>
                    <p class="text-gray-400 mt-2">探索技术的无限可能</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" 
                       class="text-gray-300 hover:text-white transition-colors duration-300">
                        <i class="fas fa-external-link-alt mr-2"></i> www.yuque.com/jtostring
                    </a>
                </div>
            </div>
            <div class="border-t border-gray-800 mt-8 pt-8 text-center text-sm text-gray-500">
                &copy; 2023 技术小馆. 保留所有权利.
            </div>
        </div>
    </footer>

    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>